// #include<iostream>
// #include<pthread.h>
// #include<memory>
// #include<string.h>
// #include<condition_variable>
// int main()
// {
//     //睡眠等待类型--block
//     pthread_mutex_t _mutex;
//     pthread_mutex_init(&_mutex);
//     pthread_mutex_lock(&_mutex);
//     pthread_mutex_unlock(&_mutex);
//     pthread_mutex_destroy(&_mutex);
//     //trylock函数--noblock模式
//     int ret = trylock(&_mutex);
//     if(ret == 0)
//     {
//         //加锁成功
//         pthread_mutex_unlock(&_mutex);
//     }
//     else if(EBUSY == ret)
//     {
//         //锁正在被使用
//     }

//     //设置可重入互斥量(递归互斥量)
//     pthread_mutex_t _mtx;
//     //声明一个互斥量属性变量
//     pthread_mutexattr__t mtx_addr;
//     //初始化属性变量
//     pthread_mutexattr_init(&mtx_addr);
//     //设置递归互斥量属性
//     pthread_mutexattr_settype(&mtx_addr,PTHREAD_MUTEX_RECURSIVE);
//     //把属性给互斥量
//     pthread_mutex_init(&_mtx,&mtx_addr);



//     //条件变量
//     pthread_cond_t _cond;
//     //互斥量
//     pthread_mutex_t mtx;

//     //初始化
//     pthread_cond_init(&_cond);
//     pthread_mutex_t(&mtx);

//     //加锁
//     pthread_mutex_lock(&mtx);
//     //加锁成功等待条件变量触发
//     pthread_cond_wait(&_cond,&mtx);

//     //加锁
//     pthread_mutex_lock(&mtx);
//     //加锁成功,唤醒条件变量
//     pthread_cond_signal(&_cond);


//     //解锁
//     pthread_mutex_unlock(&mtx);
//     pthread_mutex_destroy(&mtx);



//     pthread_mutex_t _mtx;
//     while(1)
//     {
//         if(pthread_mutex_lock(&_mtx) != 0) //加锁
//         {
//             //异常逻辑
//         }
//         while(queue.empty()) //此处while循环:防止惊群现象 2. 避免虚假唤醒
//         {
//             if(pthread_cond_wait(&cond,&_mtx) != 0)
//             {
//                 //异常逻辑
//             }
//         }
//         auto data = queue.pop();
//         if(pthread_mutex_lock(&_mtx) != 0) //加锁
//         {
//             //异常逻辑
//         }
//         process(data);//执行任务
//     }

//     pthread_rwlock_t rwlock;
//     //在读之前加读锁
//     pthread_rwlock_rdlock(&rwlock);
//     //共享资源的读操作


//     //读完释放锁
//     pthread_rwlock_unlock(&rwlock);

//     //在写之前加写锁
//     pthread_rwlock_wrlock(&rwlock);
//     //共享资源写操作
    

//     //写完释放锁
//     pthread_rwlock_unlock(&rwlock);

//     pthread_rwlock_destroy(&rwlock);

//     //un_block模式
//     pthread_rwlock_tryrdlock(&rwlock);
//     pthread_rwlock_trywrlock(&rwlock);





//     return 0;
// }




    //在多读少写场景下使用特殊数据结构减少锁的使用
    //1. 多读单写的线性数据场景,使用数组实现环形队列
    //2. 多读单写的kv数据场景,使用双缓存的数据结构来实现
    #include <pthread.h>
    #include<thread>
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    // typedef struct {
    //     int key;
    //     char value[256];
    // } Entry;
    
    // typedef struct {
    //     Entry entries[10];
    //     int count;
    // } Buffer;
    
    // Buffer buffer[2];
    // int currentbuffer = 0;
    // pthread_mutex_t lock;
    
    // void writetobuffer(int key, const char *value) {
    //     pthread_mutex_lock(&lock);
    //     int writebuffer = 1 - currentbuffer;
    //     buffer[writebuffer].entries[buffer[writebuffer].count].key = key;
    //     strncpy(buffer[writebuffer].entries[buffer[writebuffer].count].value, value, 255);
    //     buffer[writebuffer].entries[buffer[writebuffer].count].value[255] = '\0'; // Ensure null-termination
    //     buffer[writebuffer].count++;
    //     // Only switch buffer when it's full or on some condition, not after every write
    //     pthread_mutex_unlock(&lock);
    // }
    
    // const char *readfrombuffer(int key) {
    //     // Check both buffers for the key
    //     for (int b = 0; b < 2; b++) {
    //         for (int i = 0; i < buffer[b].count; i++) {
    //             if (buffer[b].entries[i].key == key) {
    //                 return buffer[b].entries[i].value;
    //             }
    //         }
    //     }
    //     return NULL;
    // }
    #include <atomic>
    #include<mutex>
    // #include<pthread.h>
    // template<typename T,size_t Capacity>
    // class RingBuffer{
    //     private:
    //         T bufffer[Capacity];
    //         std::atomic<size_t> _head;//读取位置
    //         size_t _end;//写入位置
    //         std::mutex _read_mutex;
    //     public:
    //     RingBuffer()
    //     :_head(0)
    //     ,_end(0)
    //     {
    //         pthread_mutex_init(&_read_mutex);
    //     }
    //     ~RingBuffer()
    //     {
    //         pthread_mutex_destroy(&_read_mutex);
    //     }
    //     //单写入无需加锁
    //     bool Push(const T& iter)
    //     {
    //         //计算下一个写入位置
    //         size_t next_index = (_end + 1) % Capacity;
    //         if(next_index == _head.load(std::memory_order_acquire))
    //         {
    //             return false;
    //         }
    //         buffer[_end] = iter;
    //         _end = next_index;
    //         return true;
    //     }
    //     //多读取需要加锁
    //     bool Pop(T& out)
    //     {
    //         std::unique_lock<std::mutex> lock(_read_mutex);
    //         if(_head.load(std::memory_order_relaxed) == _end)
    //         {
    //             return false;//队列为空
    //         }
    //         out = buffer[_head];
    //         _head = (_head + 1) % Capacity;
    //         return true;
    //     }
    //     bool empty()
    //     {
    //         return _head.load(std::memory_order_relaxed) == _end;
    //     }
    //     bool full()
    //     {
    //         return ((_end + 1) % Capacity) == _head.load(std::memory_order_relaxed);
    //     }
    // };
    
    // RingBuffer<int, 1024> queue;
    // void write()
    // {
    //     for(int i = 0; i < 1000; ++i)
    //     {
    //         while(!queue.Push(1))
    //         {
    //             //队列已满
    //             std::this_thread::yield();
    //         }
    //     }
    // }
    // void read(int id)
    // {
    //     int value;
    //     while(true)
    //     {
    //         if(queue.Pop(value))
    //         {
    //             std::cout<<"Reader: " << id << " got: " << value << std::endl;
    //         }
    //     }
    // }


    // pthread_spinlock_t spinlock;
    // pthread_spin_init(&spinlock,0);//pshared类型:是否进程间共享自旋锁
    // //加锁
    // pthread_spin_lock(&spinlock);
    // //解锁
    // pthread_spin_unlock(&spinlock);
    // //销毁
    // pthread_spin_destroy(&spinlock);

    //自旋锁逻辑
    while(抢锁(lock) == 没抢到)
    {

    }
    //互斥器逻辑
    while(强所(loc) == 没抢到)
    {
        本线程先去休息,请在这锁状态改变时在唤醒(lock);
    }

    //生产者消费者模型:并非每种场景下都需要独占每个资源
    加锁(lock)
    while(queue.empty())//当队列为空是等待
    {
        解锁(lock);
        //让出锁,让生产者有机会向队列中放数据
        解锁(lock);
    }
    data = queue.pop();//至此肯定非空,所以可以对资源进行操作
    解锁(lock);
    消费(data);

    改进:
    while(queue.empty())
    {
        解锁后等待等待唤醒后加锁(用来收发通知的东西,lock);
    }
    触发通知(用来收发通知的东西);




    //读写锁
    void 以读者身份加锁(rwlock)
    {
        加锁(rwlock,保护当前读者数量的锁);
        rwlock.当前读者数量 += 1;
        if(rwlock.当前读者数量 == 1)
            加锁(rwlock,保护写操作的锁);
        解锁(rwlock,保护当前读者数量的锁);
    }
    void 以读者身份解锁(rwlock)
    {
        加锁(rwlock,保护当前读者数量的锁);
        rwlock.当前读者数量 -= 1;
        if(rwlock.当前读者数量 == 0)
            解锁(rwlock,保护写操作的锁);
        解锁(rwlock,保护当前读者数量的锁);
    }

    void 以写者身份加锁(rwlock)
    {
        加锁(rwlock,保护写操作的锁);
    }
    void 以写者身份解锁(rwlock)
    {
        解锁(rwlock,保护写操作的锁);
    }
    int main() 
    {
        // pthread_mutex_init(&lock, NULL);
        // memset(buffer, 0, sizeof(buffer));
    
        // // 写入数据
        // writetobuffer(1, "value1");
        // writetobuffer(2, "value2");
    
        // // 读取数据
        // const char* value1 = readfrombuffer(1);
        // const char* value2 = readfrombuffer(2);
    
        // printf("Value for key 1: %s\n", value1);
        // printf("Value for key 2: %s\n", value2);
    
        // pthread_mutex_destroy(&lock);
        std::thread writer_thread(write);
        std::thread read_thread(read,1);
        std::thread read_thread(read,2);
        std::thread read_thread(read,3);

        writer_thread.join();
        read_thread.join();
        read_thread.join();
        read_thread.join();
        return 0;
    }